package com.springboot.jdk.atomic;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * @author: zr
 * @date: 2021-09-27
 */
public class AtomicIntegerDemo {

    private static int count = 0;
    private static AtomicInteger j = new AtomicInteger(0);

    public static void main(String[] args) {
        // synchronizedAdd();
        atomicIntegerAdd();
    }

    private static void synchronizedAdd() {
        for (int i = 0; i < 10; i++) {
            new Thread() {
                @Override
                public void run() {
                    // 如果不加 synchronized，就有可能会出现并发问题，导致 count++ 不是目标结果
                    // 但是如果这里加了 synchronized ，10个线程就要一次的慢慢的一个一个进入锁diam快
                    // 然后一次对count 变量进行 ++ 操作
                    // 每次操作完 count++ 之后，就写回到主内存，下一个线程从主内存读取数据化，在进行 count++ 操作。
                    // 这里就完全没有多线程的概念了
                    synchronized (AtomicIntegerDemo.class) {
                        try {
                            Thread.sleep(10);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName() + ":" + AtomicIntegerDemo.count++);
                    }
                }
            }.start();
        }
    }

    /**
     * 使用 AtomicInteger 来实现i++的操作
     *
     * @param
     * @return
     * @throws
     * @date 2021-09-27
     */
    private static void atomicIntegerAdd() {
        for (int i = 0; i < 10; i++) {
            new Thread() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName() + ":" + j.getAndIncrement());
                }
            }.start();
        }
    }
}
